// 代码处理工具管理
const fs = require('fs');
const codeTools = {
  // 1、测试一个数组内的所有元素是否都能通过某个指定函数的测试.数组为空返回true。数据只要有一个不符合则false。
  allEvery: (arr, fn = Boolean) => arr.every(fn),

  // 2、判断数组中的元素是否都相等
  allEqual: arr => arr.every(val => val === arr[0]),

  // 3、判断两个数字是否近似
  appproximatelyEqual: (v1,v2, epsilon = 0.001) => Math.abs(v1 - v2) < epsilon,

  // 4、将没有逗号或双引号的元素换成带有逗号分隔符的字符串，即CSV格式识别的形式
  arrayToCSV: (arr, delimiter = ',') => arr.map(v=> v.map(x => `"${x}"`).join(delimiter)).join('\n'),

  // 5、将数组元素转换成lil标签，并将此元素添加给指定的ID元素标记内。
  arrayToHtmlList: (arr, listID) => (el => (
    (el = document.querySelector('#' + listID)),
    (el.innerHTML += arr.map(item => `<li>${item}</li>`).join(''))
  ))(),

  // 6、执行一个函数，将剩余的参数传回函数当参数，返回相应的结果，并能捕获异常
  attempt: (fn, ...args) => {
    try{
      return fn(...args);
    }catch(e){
      return e instanceof Error ? e : new Error(e);
    }
  },

  // 7、返回两个或多个数的平均数
  average: (...nums) => nums.reduce((acc, val) => acc + val, 0) / nums.length,

  // 8、返回数组平均值
  averageBy: (arr, fn) => arr.map(typeof fn === 'function' ? fn : val => val[fn]).reduce((acc, val) => acc + val, 0) / arr.length,

  // 9、此函数包含两个参数，类型都为数组，依据第二个参数的真假条件，将一个参数的数组进行分组，条件为真的放入第一个数组，其它的放入第二个数组。这里运用了Array.prototype.reduce() 和 Array.prototype.push() 相结合的形式。
  bifurcate: (arr, filter) => arr.reduce((arr, val, i) => (acc[filter[i] ? 0 : i].push(val), acc), [[], []]),

  // 10、将数组按照指定的函数逻辑进行分组，满足函数条件的逻辑为真，放入第一个数组中，其它不满足的放入第二个数组。
  bifurcateBy: (arr, fn) => arr.reduce((acc, val, i) => (acc[fn(val, i) ? 0 : 1].push(val), acc), [[], []]),

  // 11、用于检测页面是否滚动到页面底部。
  bottomVisible: () => document.documentElement.clientHeight + window.scrollY >= (document.documentElement.scrollHeight || document.documentElement.clientHeight),

  // 12、返回字符串的字节长度。
  byteSize: str => new Blob([str]).size,

  // 13、将字符串的首字母转成大写
  capitalize: ([first, ...rest]) => first.toUpperCase() + rest.join(''),

  // 14、将一个句子中每个单词首字母转换成大写字母
  capitalizeEveryWord: str => str.replace(/\b[a-z]/g, char => char.toUpperCase()),

  // 15、将非数值的值转换成数组对象。
  castArray: val => (Array.isArray(val) ? val : [val]),

  // 16、将数组中移除值为 false 的内容。
  compact: arr => arr.filter(Boolean),

  // 17、统计数组中某个值出现的次数。
  countOccurrences: (arr, val) => arr.reduce((a, v) => (v === val ? a + 1 : a), 0),

  // 18、使用 existSync() 检查目录是否存在，然后使用 mkdirSync() 创建目录（如果不存在）。
  createDirIfNotExists: dir => (!fs.existsSync(dir) ? fs.mkdirSync(dir) : undefined),

  // 19、返回当前访问的 URL 地址。
  currentURL: () => window.location.href,

  // 20、返回当前是今年的第几天
  dayOfYear: date => Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 1000 / 60 / 60 / 24),

  // 21、将字符串的首字母转换成小写字母。
  decapitalize: ([first, ...rest]) => first.toLowerCase() + rest.join(''),

  // 22、通过递归的形式，将多维数组展平成一维数组。
  deepFlatten: arr => [].concat(...arr.map(v =>  (Array.isArray(v) ? deepFlatten(v) : v))),

  // 23、去重对象的属性，如果对象中含有重复的属性，以前面的为准。
  defaults: (obj, ...defs) => Object.assign({}, obj, ...defs.reverse(), obj),

  // 24、延迟函数的调用，即异步调用函数。
  defer: (fn, ...args) => setTimeout(fn, 1, ...args),

  // 25、将标准的度数，转换成弧度。
  degreesToRads = deg => (deg * Math.PI) / 180.0,

  // 26、查找两个给定数组的差异，查找出前者数组在后者数组中不存在元素。
  difference: (a, b) => {
    const s = new Set(b);
    return a.filter(x => !s.has(x));
  },

  // 27、通过给定的函数来处理需要对比差异的数组，查找出前者数组在后者数组中不存在元素。
  differenceBy: (a, b, fn) => {
    const s = new Set(b.map(fn));
    return a.filter(x => !s.has(fn(x)));
  },

  // 28、按照给定函数逻辑筛选需要对比差异的数组，查找出前者数组在后者数组中不存在元素。
  differenceWith: (arr, val, comp) => arr.filter(a => val.findIndex(b => comp(a, b)) === -1),

  // 29、将输入的数字拆分成单个数字组成的数组。
  digitize: n => [...`${n}`].map(i => parseInt(i)),

  // 30、计算两点之间的距离
  distance: (x0, y0, x1, y1) => Math.hypot(x1 - x0, y1 - y0),

  // 31、此段代码将给定的数组从左边开始删除 n 个元素
  drop: (arr, n = 1) => arr.slice(n),

  // 32、此段代码将给定的数组从右边开始删除 n 个元素
  dropRight: (arr, n = 1) => arr.slice(0, -n),

  // 33、此段代码将给定的数组按照给定的函数条件从右开始删除，直到当前元素满足函数条件为True时，停止删除，并返回数组剩余元素。
  dropRightWhile: (arr, func) => {
    while (arr.length > 0 && !func(arr[arr.length - 1])) arr = arr.slice(0, -1);
    return arr;
  },

  // 34、按照给的的函数条件筛选数组，不满足函数条件的将从数组中移除。
  dropWhile: (arr, func) => {
    while (arr.length > 0 && !func(arr[0])) arr = arr.slice(1);
    return arr;
  },

  // 35、接收两个DOM元素对象参数，判断后者是否是前者的子元素。
  elementContains: (parent, child) => parent !== child && parent.contains(child),

  // 36、移除数组中重复的元素
  filterNonUnique: arr => [ …new Set(arr)],

  // 37、按照给定的函数条件，查找第一个满足条件对象的键值。
  findKey: (obj, fn) => Object.keys(obj).find(key => fn(obj[key], key, obj)),

  // 38、按照给定的函数条件筛选数组，将最后一个满足条件的元素进行删除。
  findLast: (arr, fn) => arr.filter(fn).pop(),

  // 39、按照指定数组的深度，将嵌套数组进行展平。
  flatten: (arr, depth = 1) =>
    arr.reduce((a, v) => a.concat(depth > 1 && Array.isArray(v) ? flatten(v, depth - 1) : v), []),

    // 40、按照给定的函数条件，从数组的右边往左依次进行执行。
    forEachRight: (arr, callback) =>
      arr
        .slice(0)
        .reverse()
        .forEach(callback),

    // 41、此段代码按照给定的函数条件，支持三个参数作为输入（值、键、对象本身），进行迭代对象。
    forOwn: (obj, fn) => Object.keys(obj).forEach(key => fn(obj[key], key, obj)),

    // 42、此段代码输出函数的名称。
    functionName: fn => (console.debug(fn.name), fn),

    // 43、此段代码从Date对象里获取当前时间。
    getColonTimeFromDate: date => date.toTimeString().slice(0, 8),

    // 44、此段代码返回两个日期之间相差多少天。
    getDaysDiffBetweenDates: (dateInitial, dateFinal) =>
      (dateFinal - dateInitial) / (1000 * 3600 * 24),

    // 45、此代码返回DOM元素节点对应的属性值。
    getStyle: (el, ruleName) => getComputedStyle(el)[ruleName],

    // 46、此段代码的主要功能就是返回数据的类型。
    getType = v =>
      v === undefined ? 'undefined' : v === null ? 'null' : v.constructor.name.toLowerCase(),

    // 47、此段代码返回DOM元素是否包含指定的Class样式。
    hasClass: (el, className) => el.classList.contains(className),

    // 48、此段代码输出数组的第一个元素。
    head: arr => arr[0],

    // 49、此段代码隐藏指定的DOM元素。
    hide: (...el) => [...el].forEach(e => (e.style.display = 'none')),

    // 50、此段代码的功能就是将http网址重定向https网址。
    httpsRedirect: () => {
      if (location.protocol !== 'https:') location.replace('https://' + location.href.split('//')[1]);
    },

    // 51、此代码可以返回数组中某个值对应的所有索引值，如果不包含该值，则返回一个空数组。
    indexOfAll = (arr, val) => arr.reduce((acc, el, i) => (el === val ? [...acc, i] : acc), []),

    // 52、此段代码返回数组中除最后一个元素的所有元素。
    initial: arr => arr.slice(0, -1),

    // 53、此段代码的功能主要是在给定的DOM节点后插入新的节点内容
    insertAfter: (el, htmlString) => el.insertAdjacentHTML('afterend', htmlString),

    // 54、此段代码的功能主要是在给定的DOM节点前插入新的节点内容
    insertBefore: (el, htmlString) => el.insertAdjacentHTML('beforebegin', htmlString),

    // 55、此段代码返回两个数组元素之间的交集。
    intersection: (a, b) => {
      const s = new Set(b);
      return a.filter(x => s.has(x));
    },

    // 56、按照给定的函数处理需要对比的数组元素，然后根据处理后的数组，找出交集，最后从第一个数组中将对应的元素输出。
    intersectionBy: (a, b, fn) => {
      const s = new Set(b.map(fn));
      return a.filter(x => s.has(fn(x)));
    },

    // 57、按照给定的函数对比两个数组的差异，然后找出交集，最后从第一个数组中将对应的元素输出。
    intersectionWith: (a, b, comp) => a.filter(x => b.findIndex(y => comp(x, y)) !== -1),

    // 58、此段代码用于判断数据是否为指定的数据类型，如果是则返回true。
    is: (type, val) => ![, null].includes(val) && val.constructor === type,

    // 59、接收两个日期类型的参数，判断前者的日期是否晚于后者的日期。
    isAfterDate: (dateA, dateB) => dateA > dateB,

    // 60、接收两个日期类型的参数，判断前者的日期是否早于后者的日期。
    isBeforeDate: (dateA, dateB) => dateA < dateB,

    // 61、用于检测两个单词是否相似。
    isAnagram = (str1, str2) => {
      const normalize = str =>
        str
          .toLowerCase()
          .replace(/[^a-z0-9]/gi, '')
          .split('')
          .sort()
          .join('');
      return normalize(str1) === normalize(str2);
    },

    // 62、此段代码用于检测对象是否为类数组对象,是否可迭代。
    isArrayLike: obj => obj != null && typeof obj[Symbol.iterator] === 'function',

    // 63、此段代码用于检查参数是否为布尔类型。
    isBoolean: val => typeof val === 'boolean';isBoolean(null),

    // 64、用于判断程序运行环境是否在浏览器，这有助于避免在node环境运行前端模块时出错。
    isBrowser: () => ![typeof window, typeof document].includes('undefined'),

    // 65、用于判断当前页面是否处于活动状态（显示状态）。
    isBrowserTabFocused: () => !document.hidden,

    // 66、用于判断当前字符串是否都为小写。
    isLowerCase: str => str === str.toLowerCase(),

    // 67、用于判断当前变量的值是否为 null 或 undefined 类型。
    isNil: val => val === undefined || val === null,

    // 68、用于判断当前变量的值是否为 null 类型。
    isNull: val => val === null,

    // 69、用于检查当前的值是否为数字类型。
    isNumber: (n) => {
      return !isNaN(parseFloat(n)) && isFinite(n);
    },

    // 70、用于判断参数的值是否是对象，这里运用了Object 构造函数创建一个对象包装器，如果是对象类型，将会原值返回。
    isObject: obj => obj === Object(obj),

    // 71、用于检查参数的值是否为null以及类型是否为对象。
    isObjectLike: val => val !== null && typeof val === 'object',

    // 72、此代码段检查参数的值是否是由Object构造函数创建的对象。
    isPlainObject: val => !!val && typeof val === 'object' && val.constructor === Object,

    // 73、用于检查当前的对象是否类似Promise函数。
    isPromiseLike: obj =>
      obj !== null &&
      (typeof obj === 'object' || typeof obj === 'function') &&
      typeof obj.then === 'function',

    // 74、用于判断给定的两个日期是否是同一天。
    isSameDate: (dateA, dateB) => dateA.toISOString() === dateB.toISOString(),

    // 75、用于检查当前的值是否为字符串类型。
    isString: val => typeof val === 'string',

    // 76、用于判断参数的值是否是 Symbol 类型。
    isSymbol: val => typeof val === 'symbol',

    // 77、用于判断参数的类型是否是 Undefined 类型。
    isUndefined: val => val === undefined,

    // 78、用于判断当前字符串的字母是否都为大写。
    isUpperCase: str => str === str.toUpperCase(),

    // 79、用于判断给定的字符串是否是 JSON 字符串。
    isValidJSON: str => {
      try {
        JSON.parse(str);
        return true;
      } catch (e) {
        return false;
      }
    },

    // 80、此函数功能返回数组的最后一个元素。
    last: arr => arr[arr.length - 1],

    // 81、此函数功能用于比较两个对象，以确定第一个对象是否包含与第二个对象相同的属性与值。
    matches: (obj, source) =>
      Object.keys(source).every(key => obj.hasOwnProperty(key) && obj[key] === source[key]),

    // 82、此代码段查找日期数组中最大的日期进行输出。
    maxDate: (...dates) => new Date(Math.max.apply(null, ...dates)),

    // 83、此段代码输出数组中前 n 位最大的数。
    maxN: (arr, n = 1) => [...arr].sort((a, b) => b - a).slice(0, n),

    // 84、此代码段查找日期数组中最早的日期进行输出。
    minDate: (...dates) => new Date(Math.min.apply(null, ...dates))




};
export default codeTools;
